import env from '../config/ali-oss';
const app = getApp()

/**
 * 时间格式转换
 * @param {*} date 日期数据
 * @param {*} split 链接符
 * @param {*} hasMinute 是否有时分秒
 */
export function formatTime(date, link = '/', hasMinute = true) {
  date = new Date(date)
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()
  const ymd = [year, month, day].map(formatNumber).join(link)

  const hour = date.getHours()
  const minute = date.getMinutes()
  const second = date.getSeconds()
  const hms = [hour, minute, second].map(formatNumber).join(':')

  return `${ymd}${hasMinute ? ' ' + hms : ''}`
}

// 格式化年月日
export function formatDate(date) {
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()

  return [year, month, day].map(formatNumber).join('-');
}
// 格式化年月日时分秒
export function formatDateTime(date) {
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()
  const hour = date.getHours()
  const min = date.getMinutes()
  const sec = date.getSeconds()
  return `${[year, month, day].map(formatNumber).join('-')} ${[hour, min, sec].map(formatNumber).join(':')}`;
}

/**
 * 两位数以内的数字自动补零
 * @param {*} n 
 */
export function formatNumber(n) {
  n = n.toString()
  return n[1] ? n : '0' + n
}
/**
 * 验证手机号是否正确
 * @param {*} n 
 */
export function isPhoneRight(tel) {
  let reg_tel = /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/;
  return reg_tel.test(tel)
}

/**
 * 百度坐标转gcj02
 * @param {*} bd_lon 经度
 * @param {*} bd_lat 纬度
 */
export function baiduToGcj02(bd_lon, bd_lat) {
  var x_pi = 3.14159265358979324 * 3000.0 / 180.0;
  var x = bd_lon - 0.0065;
  var y = bd_lat - 0.006;
  var z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_pi);
  var theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_pi);
  var gg_lng = z * Math.cos(theta);
  var gg_lat = z * Math.sin(theta);
  return [gg_lng, gg_lat]
}

/**
 * 获取屏幕尺寸
 */
export function getScreenSize() {
  const systemInfo = wx.getSystemInfoSync()
  return {
    screenWidth: systemInfo.windowWidth,
    screenHeight: systemInfo.windowHeight
  }
}

/**
 * 获取屏幕尺寸比例
 */
export function getScreenScale() {
  const systemInfo = wx.getSystemInfoSync()
  return systemInfo.windowHeight / systemInfo.windowWidth
}

/**
 * 获取是否是小屏幕尺寸
 */
export function getXsScreen() {
  const scale = getScreenScale()
  return {
    isXsScreen: scale > 1.7 && scale < 1.8
  }
}

/**
 * 获取是否迷你手机
 */
export function isMiniPhone() {
  const screen = getScreenSize()
  return screen.screenWidth === 375 && screen.screenHeight === 718
}

/**
 * 函数节流
 * @param {*} fn 节流方法
 * @param {*} interval 节流时间
 */
export function throttle(fn, interval = 300) {
  // 触发的时间
  var enterTime = 0
  return function () {
    var context = this
    // 第一次函数return即触发的时间
    var backTime = new Date()
    if (backTime - enterTime > interval) {
      fn.call(context, arguments)
      // 赋值给第一次触发的时间，这样就保存了第二次触发的时间
      enterTime = backTime
    }
  }
}

/**
 * 函数防抖
 * @param {*} fn 防抖方法
 * @param {*} interval 防抖时间
 */
export function debounce(fn, interval = 1000) {
  let timer
  // 间隔时间，如果interval不传，则默认1000ms
  return function () {
    clearTimeout(timer)
    const context = this
    // 保存此处的arguments，因为setTimeout是全局的，arguments不是防抖函数需要的。
    const args = arguments
    timer = setTimeout(function () {
      fn.call(context, args)
    }, interval)
  }
}

/**
 * 对象转化为数组
 * @param {*} data 对象
 */
export function objTransferArray(data = {}) {
  const transData = Object.keys(data).map(dataKey => ({
    value: dataKey,
    label: data[dataKey],
  }))
  return transData
}

/**
 * 获取信号栏高度
 * @param {boolean} init 是否是初始化数据
 */
export function getBarAndTitleHeight(init = false) {
  if (init) {
    return {
      barHeight: 0,
      titleHeight: 0,
      signalHeight: 0
    }
  }
  const systemInfo = wx.getSystemInfoSync()
  // px转换到rpx的比例
  const pxToRpxScale = 750 / systemInfo.windowWidth
  // 状态栏的高度
  const barHeight = systemInfo.statusBarHeight * pxToRpxScale
  // 导航栏高度，这个一般是固定的
  const titleHeight = 44 * pxToRpxScale
  return {
    barHeight,
    titleHeight,
    signalHeight: systemInfo.statusBarHeight + 44
  }
}

/**
 * 获取今日日期数据
 */
export function getTodayDate() {
  const date = getStorage('date')
  const today = date ? new Date(date) : new Date()
  console.log('当前日期：', today)
  return {
    year: today.getFullYear().toString(),
    month: formatNumber(today.getMonth() + 1),
    day: formatNumber(today.getDate()),
  }
}
/**
 * 获取昨日日期数据
 */
export function getYesterdayDate() {
  const date = getStorage('date')
  const today = date ? new Date(date) : new Date()
  today.setTime(today.getTime() - 24 * 60 * 60 * 1000)
  return {
    year: today.getFullYear().toString(),
    month: formatNumber(today.getMonth() + 1),
    day: formatNumber(today.getDate()),
  }
}

/**
 * 转json字符串
 * @param {*} data 数据
 */
export function stringify(data) {
  return encodeURIComponent(JSON.stringify(data))
}

/**
 * 解析json字符串
 * @param {*} data 字符串数据
 */
export function parse(data) {
  let result
  try {
    result = JSON.parse(decodeURIComponent(data))
  } catch (e) {
    console.log('parse error', e)
  }
  return result
}

/**
 * @param {*} endTimeStamp 截止时间戳
 */
export function getDownTimeObj(endTimeStamp) {
  // 获取当前时间
  let obj = {}
  let nowTime = new Date().getTime()
  let time = (endTimeStamp - nowTime) / 1000
  if (time > 0) {
    obj = {
      stamp: time,
      day: parseInt(time / (3600 * 24)),
      hou: digitFormat(parseInt(time / 3600 % 24)),
      min: digitFormat(parseInt(time / 60 % 60)),
      sec: digitFormat(parseInt(time % 60))
    }
  } else {
    obj = {
      stamp: time,
      day: '0',
      hou: '00',
      min: '00',
      sec: '00'
    }
  }
  return obj
}

function digitFormat(param) {
  // 小于10的格式化函数
  return param < 10 ? '0' + param : param
}

/**
 * 参数拼接
 * @param {*} url 路径
 * @param {*} params 参数
 */
export function paramSplicing(url, params) {
  return Object.entries(params || {}).reduce((t, [key, value], i) => {
    return t + `${(i ? '&' : '?')}${key}=${value}`
  }, url)
}

/**
 * 跳转页面（非tab页面）
 * @param {*} name 页面名称
 * @param {*} params 页面参数
 * @param {*} options 其他参数
 */
export function jumpPage(name, params, options) {
  // 页面路径
  let url = `/pages/${name}/${name}`
  // 拼接参数
  url = paramSplicing(url, params)

  wx.navigateTo({
    url,
    ...options
  })
}

/**
 * 跳转tab页面
 * @param {*} name 页面名称
 * @param {*} params 页面参数
 * @param {*} options 其他参数
 */
export function jumpTab(name, params, options) {
  // 页面路径
  let url = `/pages/${name}/${name}`
  // 拼接参数
  url = paramSplicing(url, params)

  wx.switchTab({
    url,
    ...options
  })
}

/**
 * 跳转页面路径
 * @param {*} url 页面路径
 * @param {*} options 其他参数
 */
export function jumpUrl(url, options) {
  if (isTabPage(url)) {
    wx.switchTab({
      url,
      ...options
    })
  } else {
    wx.navigateTo({
      url,
      ...options
    })
  }
}

/**
 * 跳转页面
 * @param {*} name 页面名称
 * @param {*} params 页面参数
 * @param {*} options 其他参数
 */
export function jump(name, params, options) {
  if (isTabPage(name)) {
    jumpTab(name, params, options)
  } else {
    jumpPage(name, params, options)
  }
}

/**
 * 是否是主页面
 * @param {*} name 页面名称
 */
export function isTabPage(name) {
  // 主页面名称列表
  const tabNames = ['index', 'mine']

  return tabNames.includes(name?.split?.('/').pop()?.split('?').shift())
}



/**
 * 返回上一页
 * @param {*} delta 返回层级
 * @param {*} options 其他参数
 */
export function goBack(delta, options) {
  const pages = getCurrentPages()
  if (pages.length > 1) {
    wx.navigateBack({
      delta: delta || 1,
      ...options
    })
  } else {
    jump('index')
  }
}

/**
 * 获取当前页面地址
 */
export function getCurrentPage() {
  const pages = getCurrentPages()
  let lastPath = [...pages].pop()?.route
  if (!lastPath) {
    lastPath = wx.getLaunchOptionsSync()?.path
  }
  return `/${lastPath}`
}

// 获取场景值
export function getSceneCode() {
  return wx.getLaunchOptionsSync().scene
}


/**
 * 截取手机号，中间四位用*显示
 * @param {*} n 
 */
export function formatTelephone(n) {
  var reg = /^(\d{3})\d{4}(\d{4})$/;
  n = n.replace(reg, "$1****$2");
  return n;
}

/**
 * 四舍五入
 * @param {*} num 数字
 * @param {*} s //小数位
 */
export function fixed(num, s) {
  var times = Math.pow(10, s)
  var des = num * times + 0.5
  des = parseInt(des, 10) / times
  return des
}
/**
 * 获取存储
 * @param {*} key 
 */
export function getStorage(key) {
  if (key) {
    return wx.getStorageSync(`${__wxConfig.envVersion}_${key}`)
  }
  return null
}

/**
 * 设置存储
 * @param {*} key 
 * @param {*} val 
 */
export function setStorage(key, val) {
  if (key) {
    if (['shareSource', 'new_invite_user_id', 'invite_user_id', 'inviteData', 'smallRoutine', 'platform'].includes(key)) {
      removeStorage('shareSource')
      removeStorage('inviteData')
      removeStorage('invite_user_id')
      removeStorage('smallRoutine')
      removeStorage('platform')
    }
    wx.setStorageSync(`${__wxConfig.envVersion}_${key}`, val)
  }
}

/**
 * 删除存储
 * @param {*} key 
 */
export function removeStorage(key) {
  if (key) {
    wx.removeStorageSync(`${__wxConfig.envVersion}_${key}`)
  }
}

/**
 * 清空存储
 */
export function clearStorage() {
  wx.clearStorageSync()
}

/**
 * 获取tim用户ID
 */
export function getTimUserId(userId) {
  return `operational_tools_${__wxConfig.envVersion}_${userId}`
}

/**
 * 添加滑动效果，只适用于不可滚动页面
 * bindtouchstart="slideTouchStart" bindtouchend="slideTouchEnd" bindtouchcancel="slideTouchCancel"
 * @param {*} callback 回调函数
 */
export function slideTouch(callback) {
  return {
    // 最小偏移量
    minOffset: 30,
    // 最小滑动毫秒数
    minTime: 60,
    // 初始滑动位置X
    startX: 0,
    // 初始滑动位置Y
    startY: 0,
    // 滑动毫秒数
    startTime: 0,
    // 滑动方向
    direction: null,
    // 滑动开始
    slideTouchStart(event) {
      this.startX = event?.touches?.[0]?.pageX || 0
      this.startY = event?.touches?.[0]?.pageY || 0
      this.startTime = Date.now()
    },
    // 滑动结束
    slideTouchEnd(event) {
      // 结束位置
      const endX = event?.changedTouches?.[0]?.pageX || 0
      const endY = event?.changedTouches?.[0]?.pageY || 0
      // 滑动时间
      const touchTime = Date.now() - this.startTime

      // 开始判断
      // 1.判断时间是否符合
      if (touchTime >= this.minTime) {
        // 2.判断偏移量：分X、Y
        const xOffset = endX - this.startX
        const yOffset = endY - this.startY
        console.log('xOffset', xOffset)
        console.log('yOffset', yOffset)
        // ①条件1（偏移量x或者y要大于最小偏移量）
        // ②条件2（可以判断出是左右滑动还是上下滑动）
        if (Math.abs(xOffset) >= Math.abs(yOffset) && Math.abs(xOffset) >= this.minOffset) {
          // 左右滑动
          // ③条件3（判断偏移量的正负）
          if (xOffset < 0) {
            this.direction = 'left'
            console.log('向左滑动')
          } else {
            this.direction = 'right'
            console.log('向右滑动')
          }
        } else if (Math.abs(xOffset) < Math.abs(yOffset) && Math.abs(yOffset) >= this.minOffset) {
          // 上下滑动
          // ③条件3（判断偏移量的正负）
          if (yOffset < 0) {
            this.direction = 'top'
            console.log('向上滑动')
          } else {
            this.direction = 'bottom'
            console.log('向下滑动')
          }
        }
      } else {
        console.log('滑动时间过短', touchTime)
      }
      callback?.(this)
    },
    // 滑动取消
    slideTouchCancel() {
      this.startX = 0
      this.startY = 0
      this.startTime = 0
      this.direction = null
    }
  }
}

/**
 * 活动时间倒计时
 * @param {*} startTime 开始时间 年：月：日 时：分：秒
 * @param {*} endTime 结束时间 年：月：日 时：分：秒
 * @param {*} that 当前实例
 */
export function countDown(startTime, endTime, that) {
  if (new Date().getTime() < new Date(startTime.replace(/-/g, "/")).getTime()) {
    that.setData({
      day: '00',
      hour: '00',
      minute: '00',
      second: '00'
    })
    return
  }
  that.timeInterval = setInterval(function () { //周期计时器，每隔1秒执行一次方法里的代码
    //得到一个从现在时间开始到活动结束的时间戳 
    var downTime = parseInt(new Date(endTime.replace(/-/g, "/")).getTime() - new Date().getTime())
    // 倒计时结束
    if (downTime <= 0) {
      that.setData({
        day: '00',
        hour: '00',
        minute: '00',
        second: '00'
      })
      //结束周期计时器
      clearInterval(that.timeInterval);
      return;
    }
    //计算距离活动还有多少天、时、分、秒
    var d = parseInt(downTime / 1000 / 3600 / 24);
    var h = parseInt(downTime / 1000 / 3600 % 24);
    var m = parseInt(downTime / 1000 / 60 % 60);
    var s = parseInt(downTime / 1000 % 60);
    //统一格式的显示
    d < 10 ? d = '0' + d : d;
    h < 10 ? h = '0' + h : h;
    m < 10 ? m = '0' + m : m;
    s < 10 ? s = '0' + s : s;
    //同步显示
    that.setData({
      day: d,
      hour: h,
      minute: m,
      second: s
    })
  }, 100)
}
/**
 * 毫秒转化为时分秒
 * @params {*} time  毫秒
 */
export function formatDuring(msTime) {
  let time = msTime /1000;
  let minutes = Math.floor(time /60);
  let seconds = Math.floor(time) %60;
  // 格式 00时 00分 00秒
  if (minutes < 10) {
    minutes = '0' + minutes
  }
  if (seconds < 10) {
    seconds = '0' + seconds
  }
  return {
    // hours,
    minutes,
    seconds
  }
}
/**
 * 计时器
 * @param {*} that 当前页面实例
 * @returns {string} 时+分+秒
 */
export function timer(that) {
  let second = that.data.second
  let minute = that.data.minute
  that.timerInterval = setInterval(() => { // 设置定时器
    second++
    if (second >= 60) {
      second = 0 //  大于等于60秒归零
      minute++
      if (minute < 10) {
        // 少于10补零
        that.setData({
          minute: '0' + minute
        })
      } else {
        that.setData({
          minute: minute
        })
      }
    }
    if (second < 10) {
      // 少于10补零
      that.setData({
        second: '0' + second
      })
    } else {
      that.setData({
        second: second
      })
    }
  }, 1000)
}
/**
 * 分割搜索文字高亮显示
 * @param {*} str 查找的文字
 * @param {*} key 需要高亮显示的文字
 */
export function getInf (str, key) {
  return str.replace(new RegExp(`${key}`, 'g'), `%%${key}%%`).split('%%');
}